// 《围棋》作者版权所有。保留所有权利。
// 此源代码的使用受BSD样式
// 许可证的约束，该许可证可以在许可证文件中找到。

package poll

import (
	"internal/syscall/unix"
	"sync/atomic"
	"syscall"
)

var copyFileRangeSupported int32 = -1 // 以原子方式访问

const maxCopyFileRangeRound = 1 << 30

func kernelVersion() (major int, minor int) {
	var uname syscall.Utsname
	if err := syscall.Uname(&uname); err != nil {
		return
	}

	rl := uname.Release
	var values [2]int
	vi := 0
	value := 0
	for _, c := range rl {
		if '0' <= c && c <= '9' {
			value = (value * 10) + int(c-'0')
		} else {
			// 注意，我们在这里假设N.N.N。如果我们看到其他任何东西，我们很可能会
			// 错误地解析它。
			values[vi] = value
			vi++
			if vi >= len(values) {
				break
			}
			value = 0
		}
	}
	switch vi {
	case 0:
		return 0, 0
	case 1:
		return values[0], 0
	case 2:
		return values[0], values[1]
	}
	return
}

// CopyFileRange使用copy_file_range系统调用，将src中最多剩余字节的数据复制到dst。dst和src必须参考常规文件。
func CopyFileRange(dst, src *FD, remain int64) (written int64, handled bool, err error) {
	if supported := atomic.LoadInt32(&copyFileRangeSupported); supported == 0 {
		return 0, false, nil
	} else if supported == -1 {
		major, minor := kernelVersion()
		if major > 5 || (major == 5 && minor >= 3) {
			atomic.StoreInt32(&copyFileRangeSupported, 1)
		} else {
			// copy_file_range（2）在早于5.3的内核上以各种方式被破坏，
			// see issue#42400和
			// https:
			atomic.StoreInt32(&copyFileRangeSupported, 0)
			return 0, false, nil
		}
	}
	for remain > 0 {
		max := remain
		if max > maxCopyFileRangeRound {
			max = maxCopyFileRangeRound
		}
		n, err := copyFileRange(dst, src, int(max))
		switch err {
		case syscall.ENOSYS:
			// copy_file_range（2）是在Linux 4.5中引入的。
			// Go支持Linux>=2.6.33，因此系统调用
			// 可能不存在。
			// 
			// 如果我们看到ENOSYS，我们肯定没有传输
			// 任何数据，因此我们可以告诉调用者，我们
			// 无法处理传输，让它们返回到更通用的代码。
			// 
			// 看到ENOSYS也意味着我们不会再尝试
			// 使用copy_file_range（2）。
			atomic.StoreInt32(&copyFileRangeSupported, 0)
			return 0, false, nil
		case syscall.EXDEV, syscall.EINVAL, syscall.EIO, syscall.EOPNOTSUPP, syscall.EPERM:
			// 在Linux 5.3之前，无法跨文件系统复制文件范围。与上面的ENOSYS案例类似，如果我们看到EXDEV，我们的
			// 没有传输任何数据，我们可以让调用方
			// 返回到通用代码。
			// 
			// 至于EINVAL，这就是我们看到的，例如，如果
			// dst或src指的是管道，而不是常规的
			// 文件。这是另一种情况，没有数据已经
			// 
			// 如果src和dst在CIFS上，我们可以看到EIO。wen jian defg
			// 
			// 如果文件在NFS上，我们可以看到EOPNOTSUPP。
			// 见第40731期。
			// 
			// 如果进程在Docker容器中运行，
			// 我们可能会看到EPERM而不是ENOSYS。见
			// /#40893期。由于EPERM也可能是一个合法错误，
			// 不要将copy_file_range（2）标记为不受支持。
			return 0, false, nil
		case nil:
			if n == 0 {
				// 如果我们根本没有读取任何字节，
				// 那么这个文件可能在文件系统
				// 中，其中复制文件的范围会自动失败。
				// https:
				if written == 0 {
					return 0, false, nil
				}
				// 否则src处于EOF，这意味着
				// 我们完成了。
				return written, true, nil
			}
			remain -= n
			written += n
		default:
			return written, true, err
		}
	}
	return written, true, nil
}

// copyFileRange执行一轮复制文件范围（2）。
func copyFileRange(dst, src *FD, max int) (written int64, err error) {
	// 复制文件范围（2）的签名为：
	// 
	// ssize_t copy_文件范围（int fd_in，loff_t*off_in，
	// int fd_out，loff_t*off_out，
	// size_t len，unsigned int flags）；
	// 
	// 请注意，在对unix的调用中。CopyFileRange在下面，我们使用nil 
	// 值表示off_in和off_out。对于系统调用，这意味着
	// /“使用并更新文件偏移量”。这就是为什么我们必须为这两个文件描述符获取
	// 锁（以及为什么这整个机器首先在内部/轮询包中是
	// 锁）。
	if err := dst.writeLock(); err != nil {
		return 0, err
	}
	defer dst.writeUnlock()
	if err := src.readLock(); err != nil {
		return 0, err
	}
	defer src.readUnlock()
	var n int
	for {
		n, err = unix.CopyFileRange(src.Sysfd, nil, dst.Sysfd, nil, max, 0)
		if err != syscall.EINTR {
			break
		}
	}
	return int64(n), err
}
